Combining Linear Logic and Size Types for Implicit Complexity

Several type systems have been proposed to statically control the time complexity of lambda-calculus programs and characterize complexity classes such as FPTIME or FEXPTIME. A first line of research stems from linear logic and restricted versions of its !-modality controlling duplication. A second approach relies on the idea of tracking the size increase between input and output, and together with a restricted recursion scheme, to deduce time complexity bounds. However both approaches suffer from limitations : either a limited intensional expressivity, or linearity restrictions. In the present work we incorporate both approaches into a common type system, in order to overcome their respective constraints. Our system is based on elementary linear logic combined with linear size types, called sEAL, and leads to characterizations of the complexity classes FPTIME and 2k-FEXPTIME, for k >= 0

On Model-Checking Higher-Order Effectful Programs (Long Version)

Model-checking is one of the most powerful techniques for verifying systems and programs, which since the pioneering results by Knapik et al., Ong, and Kobayashi, is known to be applicable to functional programs with higher-order types against properties expressed by formulas of monadic second-order logic. What happens when the program in question, in addition to higher-order functions, also exhibits algebraic effects such as probabilistic choice or global store? The results in the literature range from those, mostly positive, about nondeterministic effects, to those about probabilistic effects, in the presence of which even mere reachability becomes undecidable. This work takes a fresh and general look at the problem, first of all showing that there is an elegant and natural way of viewing higher-order programs producing algebraic effects as ordinary higher-order recursion schemes. We then move on to consider effect handlers, showing that in their presence the model checking problem is bound to be undecidable in the general case, while it stays decidable when handlers have a simple syntactic form, still sufficient to capture so-called generic effects. Along the way we hint at how a general specification language could look like, this way justifying some of the results in the literature, and deriving new ones

Sized Types with Usages for Parallel Complexity of Pi-Calculus Processes

We address the problem of analysing the complexity of concurrent programs written in Pi-calculus. We are interested in parallel complexity, or span, understood as the execution time in a model with maximal parallelism. A type system for parallel complexity has been recently proposed by the first two authors but it is too imprecise for non-linear channels and cannot analyse some concurrent processes. Aiming for a more precise analysis, we design a type system which builds on the concepts of sized types and usages. The sized types allow us to parametrize the complexity by the size of inputs, and the usages allow us to achieve a kind of rely-guarantee reasoning on the timing each process communicates with its environment. We prove that our new type system soundly estimates the parallel complexity, and show through examples that it is often more precise than the previous type system of the first two authors

Open Higher-Order Logic

We introduce a variation on Barthe et al.’s higher-order logic in which formulas are interpreted as predicates over open rather than closed objects. This way, concepts which have an intrinsically functional nature, like continuity, differentiability, or monotonicity, can be expressed and reasoned about in a very natural way, following the structure of the underlying program. We give open higher-order logic in distinct flavors, and in particular in its relational and local versions, the latter being tailored for situations in which properties hold only in part of the underlying function’s domain of definition

Les Types à Tailles et leurs Applications pour l'Analyse de Complexité dans le Pi-Calcul

In this thesis, we study methods based on sized type systems for time complexity, especially for the analysis of processes in the pi-calculus, considered as a communication-based model for parallel computation. The main idea of sized types is to track the size of values in a program, and to use this information to control recursion and deduce time complexity bounds. In the first part of this thesis, we focus on a theoretical approach of complexity, following the lines of implicit computational complexity (ICC). The goal of ICC is to characterize complexity classes by means of logics or types, generally without explicit bounds. Several methods have been proposed to characterize time complexity classes. One approach comes from linear logic and restricted versions of its !-modality controlling duplication. Another approach is to focus on the sizes of values. However, both approaches suffer from limitations. The first one has a limited intensional expressivity, that is to say some natural polynomial time programs are not typable. Concerning the second approach, it is essentially linear, more precisely it does not allow for a non-linear use of higher-order arguments. In this thesis, we incorporate both approaches into a common type system, to overcome their respective constraints. We design a type system for an abstract functional language allowing non-linear functional arguments, with a seemingly good intensional expressivity. Our approach relies on elementary linear logic, combined with a system of linear sized types. We discuss the expressivity of this new type system and prove that it gives a characterization of the complexity classes FPTIME and 2k-FEXPTIME.In the second part of this thesis, we study complexity analysis with types. Type systems as a technique to analyse programs have been extensively studied, especially for functional programming languages where composition is essential. Among all the approaches for this, we focus on sized types. We explore how to extend those types to the analysis of parallel complexity in the pi-calculus. Two notions of time complexity are studied: the total computation time without parallelism (work) and the computation time under maximal parallelism (span). We define operational semantics to capture those two notions. The semantics for span is particularly important, as it allows for simpler proof methods than related notions. We present then two similar type systems from which one can extract a complexity bound on a process, inspired both by sized types and input/output types, with additional temporal information about communications. However, this extension of functional sized types for span analysis has limited expressivity, especially in presence of concurrent behaviours such as semaphores. Aiming for a more expressive analysis, we design a type system which builds on the concepts of usages, originally used for deadlock-freedom analysis.Dans cette thèse, nous étudions des méthodes basées sur les systèmes de types à tailles pour la complexité en temps, en particulier pour l’analyse des processus du pi-calcul, un modèle basé sur les communications pour les calculs parallèles. L’idée centrale des types à tailles est de tracer la taille des valeurs d’un programme et d’utiliser cette information pour contrôler la récursion et en déduire des bornes de complexité en temps. Dans la première partie de cette thèse, nous nous intéressons à une approche théorique de la complexité, dans le cadre de la complexité computationnelle implicite (ICC). L’objectif de l’ICC est de caractériser des classes de complexité en utilisant la logique ou les types, généralement sans donner de bornes explicites. Plusieurs méthodes ont été développées pour la complexité en temps. Une approche principale vient de la logique linéaire, en utilisant des versions restreintes de la modalité "!", qui contrôle la duplication. Une autre approche est de se concentrer sur la taille des valeurs. Ces deux approches ont des défauts. La première approche induit une faible expressivité intentionnelle: certains programmes naturels en temps polynomial ne sont pas typables. Pour la seconde approche, elle est essentiellement linéaire, donc elle ne permet pas en particulier une utilisation non-linéaire des arguments d’ordres supérieurs. Dans cette thèse, nous surmontons ces contraintes en combinant les deux approches dans un système de type commun. Nous élaborons un système de type pour un langage abstrait fonctionnel qui autorise des arguments fonctionnels non-linéaires avec une expressivité intentionnelle vraisemblablement correcte. Notre approche se base sur la logique linéaire élémentaire combinée avec un système de types à tailles linéaires. Nous discutons de l’expressivité de ce système de type et nous prouvons qu’il donne une caractérisation des classes de complexité FPTIME et 2k-FEXPTIME. Dans la seconde partie de cette thèse, nous étudions l’analyse de complexité avec des types. Cette approche pour analyser la complexité des programmes est un sujet de recherche important, en particulier pour les langages fonctionnels dans lesquels la notion de composition est essentielle. Parmi toutes les approches possibles, nous nous intéressons aux types à tailles. Nous explorons comment utiliser ces types pour l’analyse de complexité parallèle dans le pi-calcul. Deux notions de complexités en temps sont étudiées: le temps de calcul total sans aucune parallélisation (travail), et le temps de calcul avec une parallélisation maximale (profondeur). Nous définissons des sémantiques opérationnelles pour refléter ces deux notions. La seconde sémantique est particulièrement importante car elle donne des preuves plus simple que d’autres notions apparentées à la profondeur. Nous présentons deux systèmes de types similaires à partir duquel on peut extraire une borne de complexité sur un processus. Ces systèmes sont inspirés à la fois par les types à tailles et les types entrée/sortie du pi-calcul, auxquels on ajoute des informations temporelles. Cependant, cette extension des types à tailles fonctionnels pour l’analyse de profondeur a une expressivité limitée, en particulier en présence de certains comportements concurrents comme les sémaphores. Dans le but d’avoir une analyse plus expressive, nous élaborons un système de type qui repose sur le concept des usages, utilisés originalement pour l’analyse des deadlocks

Les Types à Tailles et leurs Applications pour l'Analyse de Complexité dans le Pi-Calcul

In this thesis, we study methods based on sized type systems for time complexity, especially for the analysis of processes in the pi-calculus, considered as a communication-based model for parallel computation. The main idea of sized types is to track the size of values in a program, and to use this information to control recursion and deduce time complexity bounds. In the first part of this thesis, we focus on a theoretical approach of complexity, following the lines of implicit computational complexity (ICC). The goal of ICC is to characterize complexity classes by means of logics or types, generally without explicit bounds. Several methods have been proposed to characterize time complexity classes. One approach comes from linear logic and restricted versions of its !-modality controlling duplication. Another approach is to focus on the sizes of values. However, both approaches suffer from limitations. The first one has a limited intensional expressivity, that is to say some natural polynomial time programs are not typable. Concerning the second approach, it is essentially linear, more precisely it does not allow for a non-linear use of higher-order arguments. In this thesis, we incorporate both approaches into a common type system, to overcome their respective constraints. We design a type system for an abstract functional language allowing non-linear functional arguments, with a seemingly good intensional expressivity. Our approach relies on elementary linear logic, combined with a system of linear sized types. We discuss the expressivity of this new type system and prove that it gives a characterization of the complexity classes FPTIME and 2k-FEXPTIME.In the second part of this thesis, we study complexity analysis with types. Type systems as a technique to analyse programs have been extensively studied, especially for functional programming languages where composition is essential. Among all the approaches for this, we focus on sized types. We explore how to extend those types to the analysis of parallel complexity in the pi-calculus. Two notions of time complexity are studied: the total computation time without parallelism (work) and the computation time under maximal parallelism (span). We define operational semantics to capture those two notions. The semantics for span is particularly important, as it allows for simpler proof methods than related notions. We present then two similar type systems from which one can extract a complexity bound on a process, inspired both by sized types and input/output types, with additional temporal information about communications. However, this extension of functional sized types for span analysis has limited expressivity, especially in presence of concurrent behaviours such as semaphores. Aiming for a more expressive analysis, we design a type system which builds on the concepts of usages, originally used for deadlock-freedom analysis.Dans cette thèse, nous étudions des méthodes basées sur les systèmes de types à tailles pour la complexité en temps, en particulier pour l’analyse des processus du pi-calcul, un modèle basé sur les communications pour les calculs parallèles. L’idée centrale des types à tailles est de tracer la taille des valeurs d’un programme et d’utiliser cette information pour contrôler la récursion et en déduire des bornes de complexité en temps. Dans la première partie de cette thèse, nous nous intéressons à une approche théorique de la complexité, dans le cadre de la complexité computationnelle implicite (ICC). L’objectif de l’ICC est de caractériser des classes de complexité en utilisant la logique ou les types, généralement sans donner de bornes explicites. Plusieurs méthodes ont été développées pour la complexité en temps. Une approche principale vient de la logique linéaire, en utilisant des versions restreintes de la modalité "!", qui contrôle la duplication. Une autre approche est de se concentrer sur la taille des valeurs. Ces deux approches ont des défauts. La première approche induit une faible expressivité intentionnelle: certains programmes naturels en temps polynomial ne sont pas typables. Pour la seconde approche, elle est essentiellement linéaire, donc elle ne permet pas en particulier une utilisation non-linéaire des arguments d’ordres supérieurs. Dans cette thèse, nous surmontons ces contraintes en combinant les deux approches dans un système de type commun. Nous élaborons un système de type pour un langage abstrait fonctionnel qui autorise des arguments fonctionnels non-linéaires avec une expressivité intentionnelle vraisemblablement correcte. Notre approche se base sur la logique linéaire élémentaire combinée avec un système de types à tailles linéaires. Nous discutons de l’expressivité de ce système de type et nous prouvons qu’il donne une caractérisation des classes de complexité FPTIME et 2k-FEXPTIME. Dans la seconde partie de cette thèse, nous étudions l’analyse de complexité avec des types. Cette approche pour analyser la complexité des programmes est un sujet de recherche important, en particulier pour les langages fonctionnels dans lesquels la notion de composition est essentielle. Parmi toutes les approches possibles, nous nous intéressons aux types à tailles. Nous explorons comment utiliser ces types pour l’analyse de complexité parallèle dans le pi-calcul. Deux notions de complexités en temps sont étudiées: le temps de calcul total sans aucune parallélisation (travail), et le temps de calcul avec une parallélisation maximale (profondeur). Nous définissons des sémantiques opérationnelles pour refléter ces deux notions. La seconde sémantique est particulièrement importante car elle donne des preuves plus simple que d’autres notions apparentées à la profondeur. Nous présentons deux systèmes de types similaires à partir duquel on peut extraire une borne de complexité sur un processus. Ces systèmes sont inspirés à la fois par les types à tailles et les types entrée/sortie du pi-calcul, auxquels on ajoute des informations temporelles. Cependant, cette extension des types à tailles fonctionnels pour l’analyse de profondeur a une expressivité limitée, en particulier en présence de certains comportements concurrents comme les sémaphores. Dans le but d’avoir une analyse plus expressive, nous élaborons un système de type qui repose sur le concept des usages, utilisés originalement pour l’analyse des deadlocks

Combining Linear Logic and Size Types for Implicit Complexity

International audienceSeveral type systems have been proposed to statically control the time complexity of lambda-calculus programs and characterize complexity classes such as FPTIME or FEXPTIME. A first line of research stems from linear logic and defines type systems based on restricted versions of the " ! " modality controlling duplication. An instance of this is light linear logic for polynomial time computation [Girard98]. A second perspective relies on the idea of tracking the size increase between input and output, and together with a restricted use of recursion, to deduce from that time complexity bounds. This second approach is illustrated for instance by non-size-increasing types [Hofmann99]. However both approaches suffer from limitations. The first one, that of linear logic, has a limited in-tensional expressivity, that is to say some natural polynomial time programs are not typable. As to the second approach it is essentially linear, more precisely it does not allow for a non-linear use of functional arguments. In the present work we adress the problem of incorporating both approaches into a common type system. The source language we consider is a lambda-calculus with data-types and iteration, that is to say a variant of Godel's system T. Our goal is to design a system for this language allowing both to handle non-linear functional arguments and to keep a good intensional expressivity. We illustrate our methodology by choosing the system of elementary linear logic (ELL) and combining it with a system of linear size types. We discuss the expressivity of this new type system and prove that it gives a characterization of the complexity classes FPTIME and 2k-FEXPTIME, for k >= 0

Combining Linear Logic and Size Types for Implicit Complexity

International audienceSeveral type systems have been proposed to statically control the time complexity of lambdacalculusprograms and characterize complexity classes such as FPTIME or FEXPTIME. A firstline of research stems from linear logic and restricted versions of its !-modality controlling duplication.A second approach relies on the idea of tracking the size increase between input and output,and together with a restricted recursion scheme, to deduce time complexity bounds. Howeverboth approaches suffer from limitations : either a limited intensional expressivity, or linearityrestrictions. In the present work we incorporate both approaches into a common type system, inorder to overcome their respective constraints. Our system is based on elementary linear logiccombined with linear size types, called sEAL, and leads to characterizations of the complexityclasses FPTIME and 2k-FEXPTIME, for k >= 0

Types for Complexity of Parallel Computation in Pi-calculus (Technical Report)

Type systems as a technique to analyse or control programs have been extensively studied for functional programming languages. In particular some systems allow to extract from a typing derivation a complexity bound on the program. We explore how to extend such results to parallel complexity in the setting of the pi-calculus, considered as a communication-based model for parallel computation. We study two notions of time complexity: the total computation time without parallelism (the work) and the computation time under maximal parallelism (the span). We define operational semantics to capture those two notions, and present two type systems from which one can extract a complexity bound on a process. The type systems are inspired both by size types and by input/output types, with additional temporal information about communications

Types for Complexity of Parallel Computation in Pi-Calculus

International audienceType systems as a technique to analyse or control programshave been extensively studied for functional programming languages. Inparticular some systems allow to extract from a typing derivation a complexitybound on the program. We explore how to extend such resultsto parallel complexity in the setting of the pi-calculus, considered as acommunication-based model for parallel computation. Two notions oftime complexity are given: the total computation time without parallelism(the work) and the computation time under maximal parallelism(the span).We dene operational semantics to capture those two notions,and present two type systems from which one can extract a complexitybound on a process. The type systems are inspired both by size typesand by input/output types, with additional temporal information aboutcommunications